<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Set</title>
  </head>
  <body>
    <div></div>
    <div></div>
    <div></div>
    <div></div>
    <div></div>
    <div></div>
    <div></div>
    <div></div>
    <script>
      /*
          Set
              - Set用来创造一个集合
              - 它的功能类似数组，不同点在于Set中不能存储重复的值

          使用方式：
            创建
              - new Set()
              - new Set([...])
            方法
              size() 获取数量
              add() 添加元素
              has() 检查元素
              delete() 删除元素

      */
      const s = new Set();
      [2, 3, 5, 4, 5, 2, 2].forEach((x) => s.add(x));
      for (var i of s) {
        console.log(i);
      }
      // 2 3 5 4
      // 上面代码通过add()方法向Set结构加入成员，结果表明Set结构不会添加重复的值。
      // Set函数可以接受一个数组(或者具有iterable接口的其他数据结构)作为参数，用来初始化
      var set = new Set([1, 2, 3, 4, 4]);
      [...set]; // [1,2,3,4]
      var items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
      items.size; // 5
      var set = new Set(document.querySelectorAll("div"));
      var b = set.size;
      console.log(b); //8
      // 可以看到Set函数不仅仅可以接受数组，还可以接受类数组对象作为参数
      // 上面的代码也展示了一种去除数组重复成员的方法、
      [...new Set([1,2,2])];
      //上面的代码也可以用于，。去除字符串里面的重复字符
      [...new Set("ababbc")].join(""); // abc
      /**
       * 向 Set 加入值的时候，不会发生类型转换，所以5和"5"是两个不同的值。
       * Set 内部判断两个值是否不同，使用的算法叫做“Same-value-zero equality”，
       * 它类似于精确相等运算符（===），主要的区别是向 Set 加入值时认为NaN等于自身，
       * 而精确相等运算符认为NaN不等于自身。
       */
      var set = new Set();
      var a = NaN;
      var b = NaN;
      set.add(a);
      set.add(b);
      console.log(set); // Set {NaN}
      // 上面代码向 Set 实例添加了两次NaN，但是只会加入一个。这表明，在 Set 内部，两个NaN是相等的。
      // 另外。俩个对象总是不相等的
      var set = new Set();

      set.add({});
      set.size; // 1

      set.add({});
      set.size; // 2
      // 上面代码表示，由于两个空对象不相等，所以它们被视为两个值。
    </script>
    <script>
      // Set实例的属性
      // 1. Set.prototype.constructor: 构造函数，默认就是Set函数。
      // 2. Set.prototype.size: 返回Set实例的成员总数。
      // Set实例的方法：分为俩大类，操作方法(用于操作数据)，和遍历方法(用于遍历成员)。
      /**
      1.Set.prototype.add(value): 添加某个值，返回Set结构本身。
      2.Set.prototype.delete(value): 删除某个值，返回一个布尔值，表示删除是否成功。
      3.Set.prototype.has(value): 返回一个值，表示该值是否为Set成员。
      4.Set.prototype.clear(): 清除所有成员，没有返回值。
      */
      // 下面是一个对比，看看在判断是否包括一个键上面，Object结构和Set结构的写法不同。
      // 对象的写法
      var properties = {
        'width': 1,
        'height': 1
      }
      if (properties[someName]) {
        // do something
      }
      // Set的写法
      var properties = new Set();
      properties.add('width');
      properties.add('height');
      if(properties.has(someName)) {
        // do something
      };
      // Array.from方法可以将Set结构转为数组。
      var items = new Set([1,2,3,4,5]);
      var arr = Array.from(items);
      // 先转为set在转回array就可以去重了！
    </script>
    <script>
      // Set结构的实例有四个遍历方法，可以用于遍历成员。
      // Set.prototype.keys()：返回键名的遍历器
      // Set.prototype.values()：返回键值的遍历器
      // Set.prototype.entries()：返回键值对的遍历器
      // Set.prototype.forEach()：使用回调函数遍历每个成员
      // 需要特别指出的是，Set的遍历顺序就是插入顺序，这个特性有时，非常有用，比如使用Set保存一个回调函数列表，
      // 调用时就能保证按照添加顺序调用。
      // keys方法、values方法、entries方法返回的都是遍历器对象（详见《Iterator 对象》一章）。由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys方法和values方法的行为完全一致。
      Set.prototype[Symbol.iterator] === Set.prototype.values // true
      //Set结构的实例默认可遍历，它的默认遍历器生成函数就它的values方法
      // 这意味着，可以省略values方法，使用for...of循环遍历Set
      var set = new Set(['red', 'green', 'blue']);
      for (let x of set) {
        console.log(x) //red green blue
      }
      // Set结构的实例与数组一样，也拥有forEach方法，对于每个成员执行某种操作，没有返回值。
      var set = new Set([1,4,9]);
      set.forEach((value, key) => console.log(key + ':' + value))
      // 1 : 1
      // 4 : 4
      // 9 : 9
      /**
       * 上面代码说明，forEach方法的参数就是一个处理函数，该函数的参数与数组的forEach一致，依次为键值，
       * 键名、集合本身(上例省略了该参数)。这里需要注意，Set结构的键名就是键值，(俩者是同一个值)，
       * 因此第一个参数与第二个参数的值永远都是一样的，
       * 另外，forEach方法还有第二个参数，表示绑定处理函数内部的this对象。
      */
     // 扩展运算符。。。内部使用for...of循环，所以也可以用于Set结构。
     var set = new set([1,2,3])
     var arr = [...set];
     // 数组的map和filter方法也可以间接用于Set了。
     // 使用Set可以很容易地实现并集(Union)、 交集(intersect)和差集(Difference)
     var a = new Set([1,2,3]);
     var b = new Set([4,3,2]);
     //并集
     var union = new Set([...a, ...b])
     // Set {1, 2, 3, 4}
     //交集
     var intersect = new Set([...a].filter(x => b.has(x)))
     // Set { 2, 3}
     // 差集(a 相对于 b)
     var difference = new Set([...a].filter(x => !b.has(x)));
     // Set {1}
     /**
      * 如果想在遍历操作中，同步改变原来的Set结构，目前没有直接的方法，但又俩种变通方法
      * 一种是利用原Set结构映射出一个新的结构，然后赋值给原来的Set结构，
      * 另一种是利用Array.from方法
     */
    // 方法 一
    var set = new Set([1,2,3]);
    set = new Set([...set].map(val => val * 2));
    // set的值是2,4,6
    // 方法二
    set = new Set(Array.from(set, val => val * 2)); // set的值是2,4,6
    </script>

    <script>
      const aaa = 10
      const bbb = 10
      const abSet = new Set([aaa,bbb])
      console.log('abset---->', abSet) // [10]
    </script>
  </body>
</html>
